# 01串
# 2025/5/23

"""
给定一个由 0, 1, 2, 3 · · · 的二进制表示拼接而成的长度无限的 01 串。

其前若干位形如 011011100101110111 · · · 。

请求出这个串的前 x 位里有多少个 1。
"""
from collections import deque, Counter


def count_one(n: int):
    """
    通过率: 12/20 其余超时
    把这个序列想想成一个二叉树
                                                |  长度   | 1的个数 |
                      1                         |  1     |  1     |
             10                 11              |  2 * 2 |  3     | 2 * 1 + 1
        100      101       110       111        |  4 * 2 |  8     | 2 * 3 + 2
    1000 1001 1010 1011 1100 1101 1110 1111     |  8 * 2 |  20    | 2 * 8 + 4
    """
    cnt = 0
    que = deque(["1"])
    length = 1
    while length < n:
        curr = que.popleft()
        if length + len(curr) >= n:
            remain = n - length
            cnt += Counter(curr[:remain]).get("1")
            return cnt
        else:
            cnt += Counter(curr).get("1")
            length += len(curr)
            que.append(curr + "0")
            que.append(curr + "1")


def count_one_opt(n: int):
    """
    通过率: 20/20
    在把所有自然数的二进制（不含前导零）依次拼接成一个长串后，
    取前 n 位，统计其中 '1' 的个数。
    """
    total_ones = 0    # 累计的 '1' 数
    total_bits = 0    # 已吞掉的位数
    k = 1             # 正在处理的“块”的二进制长度

    # --- 处理 k = 1 的“块”（数字 0 和 1，总共 2 位） ---
    if n > 0:
        block_bits = 2  # "0"(1位) + "1"(1位)
        if total_bits + block_bits > n:
            # 只能部分吞：剩余 left 位
            left = n - total_bits
            # 在 "01" 这两位中，第二位是 '1'
            total_ones += 1 if left >= 2 else 0
            return total_ones
        # 能吞完整个 "01"
        total_ones += 1   # 只有数字 "1" 那一位是 '1'
        total_bits  += 2
        k = 2

    # --- 处理 k >= 2 的块 ---
    while True:
        # 这一块里数字的个数 m = 2^(k-1)，占位 = k * m
        m = 1 << (k - 1)
        block_bits = k * m

        # 如果“吞掉整块”后还没超过 x，就先一次性加上整块贡献
        if total_bits + block_bits <= n:
            # 整块里 '1' 的总数公式：(k+1) * 2^(k-2)
            total_ones += (k + 1) * (1 << (k - 2))
            total_bits += block_bits
            k += 1
            continue

        # --- 吞不下整块，只能部分吞 ---
        left = n - total_bits               # 剩余可吞位数
        full_nums = min(left // k, m)      # 能完整吞的数字个数 t
        rem_bits  = left - full_nums * k   # 最后半个数字只吞的位数 r

        # 1) 先算前 full_nums 个数字里 '1' 的总数
        ones = full_nums  # 最高位都为 1，共 t 个
        # 对每一个更低的第 b 位做“周期统计”
        for b in range(k - 1):
            cycle = 1 << (b + 1)
            full_cycles = full_nums // cycle
            rem = full_nums % cycle
            ones += full_cycles * (1 << b)
            if rem > (1 << b):
                ones += rem - (1 << b)

        total_ones += ones

        # 2) 再算那个被截断的数字前 rem_bits 位里的 '1'
        if rem_bits > 0:
            # 该数字是块内的第 (t+1) 个：值 = 2^(k-1) + t
            cur = (1 << (k - 1)) + full_nums
            # 取它的高 rem_bits 位，等价于右移 (k - rem_bits)
            high_part = cur >> (k - rem_bits)
            total_ones += high_part.bit_count()

        return total_ones

if __name__ == '__main__':
    n = int(input())
    print(count_one(n))
    # print(count_one_opt(n))
